home *** CD-ROM | disk | FTP | other *** search
/ Nautilus 1992 July / Nautilus-3-8 / Nautilus-3-8.bin / Tools & Utilities / Techy Stuff / Source ƒ / Filelist ƒ / File.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-14  |  6.2 KB  |  284 lines
  1. /*
  2.     FileList 1.4
  3.     "File.c"
  4. */
  5.  
  6. #include "Main.h"
  7. #include "Utilities.h"
  8. #include "Stack.h"
  9. #include "Search.h"
  10. #include "File.h"
  11.  
  12. typedef struct {            /* Header structure of file */
  13.     long    version;        /* File version */
  14.     long    type;            /* 'FILI' */
  15.     long    creator;        /* 'FILI' */
  16.     long    infosize;        /* Size (bytes) of info */
  17.     long    infocount;        /* Number of records */
  18.     long    volumecount;    /* Number of volumes */
  19.     long    filecount;        /* Number of files */
  20.     short    volumesort;        /* How volumes are sorted */
  21.     short    filesort;        /* How files are sorted */
  22.     long    filler[8];
  23. } Header;
  24.  
  25. /* ----- Copy selection to clipboard ------------------------------------ */
  26.  
  27. void CopySelection (register WindowDataPtr w)
  28. {
  29.     register unsigned char s[256];
  30.     register unsigned char buf[512];
  31.     register unsigned char *p;
  32.     register unsigned short n;
  33.     StringHandle str;
  34.  
  35.     if (!w || ((WindowPeek)w)->windowKind < 0 || w->select == -1)
  36.         return;
  37.     ZeroScrap();
  38.     p = buf;
  39.     if (!Tabs && (str = GetString(w->header))) {
  40.         BlockMove(*str + 1, p, n = **str);
  41.         p += n;
  42.         *p++ = '\r';
  43.     }
  44.     (*(w->string))(w->select, s);
  45.     BlockMove(s + 1, p, n = *s);
  46.     p += n;
  47.     *p++ = '\r';
  48.     PutScrap(p - buf, 'TEXT', buf);
  49. }
  50.  
  51. /* ----- Save text of window -------------------------------------------- */
  52.  
  53. void DoSaveText (register WindowDataPtr w)
  54. {    
  55.     register short err;
  56.     register long i;
  57.     StringHandle str;
  58.     SFReply sfr;
  59.     short r;
  60.     long count;
  61.     Point where;
  62.     unsigned char s[256];
  63.  
  64.     if (!w || (((WindowPeek)w)->windowKind < 0))
  65.         return;
  66.     GetDlogOrigin(putDlgID, &where);
  67.     if (w->vrefnum) {
  68.         SetVol(0L, w->vrefnum);
  69.         BlockMove(w->fname, s, w->fname[0] + 1L);
  70.     } else {
  71.         str = GetString(w->title);
  72.         BlockMove(*str, s, **str + 1L);
  73.     }
  74.     HLock(str = GetString(SAVE_TEXT_AS));
  75.     SFPutFile(where, *str, s, SFOutlineHook, &sfr);
  76.     HUnlock(str);
  77.     if (!sfr.good)
  78.         return;
  79.  
  80.     FSDelete(sfr.fName, sfr.vRefNum);
  81.     if ((err = Create(sfr.fName, sfr.vRefNum, TextCreator, 'TEXT')) ||
  82.         (err = FSOpen(sfr.fName, sfr.vRefNum, &r)))
  83.         goto done2;
  84.     SetWatch();
  85.     if (!Tabs && (str = GetString(w->header))) {
  86.         BlockMove(*str, s, **str + 1L);
  87.         Append(s, CrStr);
  88.         count = *s;
  89.         if (err = FSWrite(r, &count, s + 1))
  90.             goto done1;
  91.     }
  92.     for (i = 0; i < w->count; i++) {
  93.         (*(w->string))(i, s);
  94.         Append(s, CrStr);
  95.         count = *s;
  96.         if (err = FSWrite(r, &count, s + 1))
  97.             goto done1;
  98.     }
  99. done1:
  100.     FSClose(r);
  101.     FlushVol(0L, sfr.vRefNum);
  102.     InitCursor();
  103. done2:
  104.     if (err)
  105.         Message(ERR_DISK, err);
  106.     else {
  107.         w->vrefnum = sfr.vRefNum;
  108.         BlockMove(sfr.fName, w->fname, sfr.fName[0] + 1L);
  109.     }
  110. }
  111.  
  112. /* ----- Save all records ---------------------------------------------- */
  113.  
  114. Boolean DoSave (register Boolean ask)
  115. {    
  116.     register short err;
  117.     register long i;
  118.     StringHandle str;
  119.     SFReply sfr;
  120.     short r;
  121.     long count;
  122.     Point where;
  123.     Header header;
  124.     unsigned char s[256];
  125.  
  126.     if (VrefNum) {
  127.         SetVol(0L, VrefNum);
  128.         sfr.vRefNum = VrefNum;
  129.         BlockMove(Fname, sfr.fName, Fname[0] + 1L);
  130.         BlockMove(Fname, s, Fname[0] + 1L);
  131.     } else {
  132.         ask = TRUE;
  133.         str = GetString(SAVENAME);
  134.         BlockMove(*str, s, **str + 1L);
  135.     }
  136.     if (ask) {
  137.         GetDlogOrigin (putDlgID, &where);
  138.         HLock(str = GetString(SAVE_FILE_AS));
  139.         SFPutFile(where, *str, s, SFOutlineHook, &sfr);
  140.         HUnlock(str);
  141.         if (!sfr.good)
  142.             return FALSE;    /* Cancel */
  143.     }
  144.     if (VolumeData.select != -1L)
  145.         Select(&VolumeData, VolumeData.select, FALSE);
  146.     if (FileData.select != -1L)
  147.         Select(&FileData, FileData.select, FALSE);
  148.  
  149.     if ((err = FSOpen(sfr.fName, sfr.vRefNum, &r)) == fnfErr) {
  150.         if (err = Create(sfr.fName, sfr.vRefNum, Creator, Creator))
  151.             goto done2;
  152.         err = FSOpen(sfr.fName, sfr.vRefNum, &r);
  153.     }
  154.     if (err)
  155.         goto done2;
  156.     SetWatch();
  157.  
  158.     count = sizeof(header);
  159.     FillMemory((unsigned char *)&header, count, 0);
  160.     header.version = VERSION;
  161.     header.type = Creator;
  162.     header.creator = Creator;
  163.     header.infosize = InfoSize;
  164.     header.infocount = InfoCount;
  165.     header.volumecount = VolumeData.count;
  166.     header.filecount = FileData.count;
  167.     header.volumesort = VolumeData.sorted;
  168.     header.filesort = FileData.sorted;
  169.     count = sizeof(header);
  170.     if (err = FSWrite(r, &count, &header))
  171.         goto done1;
  172.  
  173.     count = InfoSize;
  174.     if (err = FSWrite(r, &count, InfoBase))
  175.         goto done1;
  176.  
  177.     count = VolumeData.count * sizeof(long);
  178.     if (err = FSWrite(r, &count, VolumeData.base))
  179.         goto done1;
  180.  
  181.     count = FileData.count * sizeof(long);
  182.     err = FSWrite(r, &count, FileData.base);
  183. done1:
  184.     FSClose(r);
  185.     FlushVol(0L, sfr.vRefNum);
  186.     InitCursor();
  187. done2:
  188.     if (err)
  189.         Message(ERR_DISK, err);
  190.     else {
  191.         Dirty = FALSE;
  192.         VrefNum = sfr.vRefNum;
  193.         BlockMove(sfr.fName, Fname , sfr.fName[0] + 1L);
  194.     }
  195.     Update();
  196.     return TRUE;
  197. }
  198.  
  199. /* ----- Read all records ---------------------------------------------- */
  200.  
  201. void Read (
  202.     short vRefNum,
  203.     unsigned char *fName)
  204. {    
  205.     register short err;
  206.     short r;
  207.     long count;
  208.     Header header;
  209.  
  210.     if (err = FSOpen(fName, vRefNum, &r))
  211.         goto done2;
  212.     SetWatch();
  213.  
  214.     count = sizeof(header);
  215.     if (err = FSRead(r, &count, &header))
  216.         goto done1;
  217.     if (header.version != VERSION ||
  218.         header.type != Creator ||
  219.         header.creator != Creator) {
  220.         err = 9999;
  221.         goto done1;
  222.     }
  223.     if (header.infosize > InfoMax ||
  224.         header.volumecount > VolumeData.max ||
  225.         header.filecount > FileData.max) {
  226.         err = 10000;
  227.         goto done1;
  228.     }
  229.     InfoSize = header.infosize;
  230.     InfoCount = header.infocount;
  231.     VolumeData.count = header.volumecount;
  232.     FileData.count = header.filecount;
  233.  
  234.     count = InfoSize;
  235.     if (err = FSRead(r, &count, InfoBase))
  236.         goto done1;
  237.  
  238.     count = VolumeData.count * sizeof(long);
  239.     if (err = FSRead(r, &count, VolumeData.base))
  240.         goto done1;
  241.  
  242.     count = FileData.count * sizeof(long);
  243.     if (err = FSRead(r, &count, FileData.base))
  244.         goto done1;
  245.  
  246.     VolumeData.sorted = header.volumesort;
  247.     FileData.sorted = header.filesort;
  248. done1:
  249.     FSClose(r);
  250.     InitCursor();
  251. done2:
  252.     if (err)
  253.         Message(ERR_DISK, err);
  254.     else {
  255.         Dirty = FALSE;
  256.         VrefNum = vRefNum;
  257.         BlockMove(fName, Fname , fName[0] + 1L);
  258.     }
  259. }
  260.  
  261. /* ----- Open command -------------------------------------------------- */
  262.  
  263. void DoOpen (void)
  264. {    
  265.     SFReply sfr;
  266.     Point where;
  267.  
  268.     if (SaveBefore()) {
  269.         ClearSorted(&FileData);
  270.         ClearSorted(&VolumeData);
  271.         GetDlogOrigin (getDlgID, &where);
  272.         SFGetFile (where, EmptyStr, 0L, 1, &Creator, SFOutlineHook, &sfr);
  273.         if (sfr.good) {
  274.             Read(sfr.vRefNum, sfr.fName);
  275.             Update();
  276.             VolumeData.select = FileData.select = -1L;
  277.             if (FileData.sorted)
  278.                 CheckItem(FileData.sortmenu, FileData.sorted, TRUE);
  279.             if (VolumeData.sorted)
  280.                 CheckItem(VolumeData.sortmenu, VolumeData.sorted, TRUE);
  281.         }
  282.     }
  283. }
  284.